package com.ddx.common.util;


import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.servlet.http.HttpServletRequest;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author dudianbo
 * @ClassName: DataUtil
 * @Description: ${DESCRIPTION}
 * @date 2018/3/15
 */
public class DataUtil {
    private static Logger logger = LoggerFactory.getLogger(DataUtil.class);
    /**
     * 身份证号加密
     * @param idNo
     * @return
     */
    public static String idNoEncryp(String idNo){
        if(idNo==null||idNo.length()<10){
            return idNo;
        }
        String entryFrontNo=idNo.substring(0,6);
        String entryAfterNo=idNo.substring(idNo.length()-4,idNo.length());
        Integer length=idNo.length()-entryFrontNo.length()-entryAfterNo.length();
        for(int i=0;i<length;i++){
            entryFrontNo=entryFrontNo+"*";
        }
        entryFrontNo=entryFrontNo+entryAfterNo;
        return entryFrontNo;
    }

    /**
     * 电话号加密
     * @param phoneNo
     * @return
     */
    public static String phoneNoEncryp(String phoneNo){
        if(phoneNo==null||phoneNo.length()<7){
            return phoneNo;
        }
        String entryFrontNo=phoneNo.substring(0,3);
        String entryAfterNo=phoneNo.substring(phoneNo.length()-4,phoneNo.length());
        Integer length=phoneNo.length()-entryFrontNo.length()-entryAfterNo.length();
        for(int i=0;i<length;i++){
            entryFrontNo=entryFrontNo+"*";
        }
        entryFrontNo=entryFrontNo+entryAfterNo;
        return entryFrontNo;
    }

    /**
     * 姓名加密
     * @param name
     * @return
     */
    public static String nameEncryp(String name){
        if(name==null||name.length()<=1){
            return name;
        }

        String entryName=name.substring(0,1);
        Integer length=name.length()-entryName.length();
        for(int i=0;i<length;i++){
            entryName=entryName+"*";
        }
        return entryName;
    }

    /**
     * 金额加逗号
     * @param data
     * @return
     */
    public static String formatTosepara(BigDecimal data) {
        DecimalFormat df = new DecimalFormat("#,##0.00");
        return df.format(data);
    }
    /**
     * 以0补齐位
     * @param no
     * @param j
     * @return
     */
    public static String addZeroStr(String no, int j) {
        StringBuffer str = new StringBuffer(no);
        for (int i = str.length(); i < j; i++) {
            str.insert(0, "0");
        }
        return str.toString();
    }
    /**
     * 获取Ip地址
     * @param request
     * @return
     */
    public static String getIpAdrress(HttpServletRequest request) {
        String Xip = request.getHeader("X-Real-IP");
        String XFor = request.getHeader("X-Forwarded-For");
        if(StringUtils.isNotEmpty(XFor) && !"unKnown".equalsIgnoreCase(XFor)){
            //多次反向代理后会有多个ip值，第一个ip才是真实ip
            int index = XFor.indexOf(",");
            if(index != -1){
                return XFor.substring(0,index);
            }else{
                return XFor;
            }
        }
        XFor = Xip;
        if(StringUtils.isNotEmpty(XFor) && !"unKnown".equalsIgnoreCase(XFor)){
            return XFor;
        }
        if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {
            XFor = request.getHeader("Proxy-Client-IP");
        }
        if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {
            XFor = request.getHeader("WL-Proxy-Client-IP");
        }
        if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {
            XFor = request.getHeader("HTTP_CLIENT_IP");
        }
        if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {
            XFor = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {
            XFor = request.getRemoteAddr();
        }
        return XFor;
    }
    /**
     * 获取随机数字
     *
     * @param len
     * @return
     */
    public static String getRandomStr(int len) {
        double d1 = Math.pow(10, len - 1);
        double d2 = d1 * Math.random() / 2;
        long n = new Double(d1 + d2).longValue();
        return String.valueOf(n);
    }


    /**
     *  消0
     * @param rateStr
     * @return
     */
    public static String zeroSuppression(String rateStr) {
        if(rateStr.indexOf(".") > 0){
            //正则表达
            rateStr = rateStr.replaceAll("0+?$", "");//去掉后面无用的零
            rateStr = rateStr.replaceAll("[.]$", "");//如小数点后面全是零则去掉小数点
        }
        return rateStr;

    }

    public static String threeSplit(String str){
        str = new StringBuffer(str).reverse().toString(); // 先将字符串颠倒顺序
        String str2 = "";

        int size = (str.length() % 3 == 0) ? (str.length() / 3) : (str.length() / 3 + 1); // 每三位取一长度

    /*
     * 比如把一段字符串分成n段,第n段可能不是三个数,有可能是一个或者两个,
     * 现将字符串分成两部分.一部分为前n-1段,第二部分为第n段.前n-1段，每一段加一",".而第n段直接取出即可
     */
        for (int i = 0; i < size - 1; i++)
        { // 前n-1段
            str2 += str.substring(i * 3, i * 3 + 3) + ",";
        }

        for (int i = size - 1; i < size; i++)
        { // 第n段
            str2 += str.substring(i * 3, str.length());
        }

        str2 = new StringBuffer(str2).reverse().toString();

        return str2;
    }
    public static String unicodeToCn(String unicode) {
        /** 以 \ u 分割，因为java注释也能识别unicode，因此中间加了一个空格*/
        String[] strs = unicode.split("\\\\u");
        String returnStr = "";
        // 由于unicode字符串以 \ u 开头，因此分割出的第一个字符是""。
        for (int i = 1; i < strs.length; i++) {
            returnStr += (char) Integer.valueOf(strs[i], 16).intValue();
        }
        return returnStr;
    }
    //图片转化成base64字符串
    public static String GetImageStr()
    {//将图片文件转化为字节数组字符串，并对其进行Base64编码处理
        String imgFile = "C:\\chedaidai\\a.png";//待处理的图片
        InputStream in = null;
        byte[] data = null;
        //读取图片字节数组
        try
        {
            in = new FileInputStream(imgFile);
            data = new byte[in.available()];
            in.read(data);
            in.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        //对字节数组Base64编码
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(data);//返回Base64编码过的字节数组字符串
    }

    //base64字符串转化成图片
    public static  byte[] GenerateImage(String imgStr)
    {   //对字节数组字符串进行Base64解码并生成图片
        if (imgStr == null) //图像数据为空
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        try {
            //Base64解码
            byte[] b = decoder.decodeBuffer(imgStr);
            for(int i=0;i<b.length;++i)
            {
                if(b[i]<0)
                {//调整异常数据
                    b[i]+=256;
                }
            }
            return b;
        } catch (Exception e) {
            return null;
        }
    }
}
